\hypertarget{keycpp_8h}{\section{keycpp.\-h File Reference}
\label{keycpp_8h}\index{keycpp.\-h@{keycpp.\-h}}
}
{\ttfamily \#include $<$iostream$>$}\\*
{\ttfamily \#include $<$iomanip$>$}\\*
{\ttfamily \#include $<$complex$>$}\\*
{\ttfamily \#include $<$vector$>$}\\*
{\ttfamily \#include $<$string$>$}\\*
{\ttfamily \#include $<$cmath$>$}\\*
{\ttfamily \#include $<$boost/numeric/odeint.\-hpp$>$}\\*
{\ttfamily \#include $<$boost/range.\-hpp$>$}\\*
{\ttfamily \#include $<$utility$>$}\\*
{\ttfamily \#include $<$algorithm$>$}\\*
{\ttfamily \#include $<$limits$>$}\\*
{\ttfamily \#include $<$ctime$>$}\\*
{\ttfamily \#include $<$stdarg.\-h$>$}\\*
{\ttfamily \#include \char`\"{}vector\-\_\-k.\-h\char`\"{}}\\*
{\ttfamily \#include \char`\"{}Matrix.\-h\char`\"{}}\\*
{\ttfamily \#include \char`\"{}\-\_\-kiss\-\_\-fft\-\_\-guts.\-h\char`\"{}}\\*
{\ttfamily \#include \char`\"{}Spline.\-h\char`\"{}}\\*
{\ttfamily \#include \char`\"{}Figure.\-h\char`\"{}}\\*
{\ttfamily \#include \char`\"{}Sparse\-Matrix.\-h\char`\"{}}\\*
{\ttfamily \#include \char`\"{}znaupd.\-h\char`\"{}}\\*
\subsection*{Classes}
\begin{DoxyCompactItemize}
\item 
class \hyperlink{classkeycpp_1_1_key_cpp_exception}{keycpp\-::\-Key\-Cpp\-Exception}
\item 
struct \hyperlink{structkeycpp_1_1observe}{keycpp\-::observe$<$ T, U $>$}
\item 
struct \hyperlink{structboost_1_1numeric_1_1odeint_1_1is__resizeable_3_01keycpp_1_1matrix_3_01_t_00_012_01_4_01_4}{boost\-::numeric\-::odeint\-::is\-\_\-resizeable$<$ keycpp\-::matrix$<$ T, 2 $>$ $>$}
\item 
struct \hyperlink{structkeycpp_1_1_o_d_e__type}{keycpp\-::\-O\-D\-E\-\_\-type$<$ T, Y $>$}
\item 
struct \hyperlink{structkeycpp_1_1_sort___matrix}{keycpp\-::\-Sort\-\_\-\-Matrix$<$ T $>$}
\item 
class \hyperlink{classkeycpp_1_1_s_v_d__type}{keycpp\-::\-S\-V\-D\-\_\-type$<$ T, X $>$}
\item 
struct \hyperlink{structkeycpp_1_1tictoc__type}{keycpp\-::tictoc\-\_\-type}
\begin{DoxyCompactList}\small\item\em Data type for using the \hyperlink{namespacekeycpp_a6069a9eec0edfa1d401230013d98765e}{tic()} and toc(tictoc\-\_\-type Timer) commands. \end{DoxyCompactList}\item 
struct \hyperlink{structkeycpp_1_1meshgrid__type}{keycpp\-::meshgrid\-\_\-type$<$ T, U $>$}
\end{DoxyCompactItemize}
\subsection*{Namespaces}
\begin{DoxyCompactItemize}
\item 
\hyperlink{namespacekeycpp}{keycpp}
\begin{DoxyCompactList}\small\item\em The keycpp namespace prevents Key\-Cpp functions and classes from interfering with other C++ libraries, for instance the std library. \end{DoxyCompactList}\end{DoxyCompactItemize}
\subsection*{Constant Groups}
\begin{DoxyCompactItemize}
\item 
\hyperlink{namespacekeycpp}{keycpp}
\begin{DoxyCompactList}\small\item\em The keycpp namespace prevents Key\-Cpp functions and classes from interfering with other C++ libraries, for instance the std library. \end{DoxyCompactList}\end{DoxyCompactItemize}
\subsection*{Functions}
\begin{DoxyCompactItemize}
\item 
\hypertarget{namespacekeycpp_a55e50932cc54f92bdd7e38c6438f4f1f}{double \hyperlink{namespacekeycpp_a55e50932cc54f92bdd7e38c6438f4f1f}{keycpp\-::ddot\-\_\-} (const int $\ast$N, const double $\ast$a, const int $\ast$inca, const double $\ast$b, const int $\ast$incb)}\label{namespacekeycpp_a55e50932cc54f92bdd7e38c6438f4f1f}

\begin{DoxyCompactList}\small\item\em This provides a C interface to B\-L\-A\-S's double dot product function. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_a2ce99b4fe4a13b9c70ada81761eb0ca2}{void \hyperlink{namespacekeycpp_a2ce99b4fe4a13b9c70ada81761eb0ca2}{keycpp\-::zdotu\-\_\-} (std\-::complex$<$ double $>$ $\ast$result, const int $\ast$N, const std\-::complex$<$ double $>$ $\ast$a, const int $\ast$inca, const std\-::complex$<$ double $>$ $\ast$b, const int $\ast$incb)}\label{namespacekeycpp_a2ce99b4fe4a13b9c70ada81761eb0ca2}

\begin{DoxyCompactList}\small\item\em This provides a C interface to B\-L\-A\-S's complex double dot product function. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_ae99c5b242a21ba683701ccb6ab6534b1}{void \hyperlink{namespacekeycpp_ae99c5b242a21ba683701ccb6ab6534b1}{keycpp\-::daxpy\-\_\-} (const int $\ast$N, const double $\ast$alpha, const double $\ast$x, const int $\ast$incx, double $\ast$y, const int $\ast$incy)}\label{namespacekeycpp_ae99c5b242a21ba683701ccb6ab6534b1}

\begin{DoxyCompactList}\small\item\em This provides a C interface to B\-L\-A\-S's double vector addition function. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_a6460fa334239dde761d8f737b9438fed}{void \hyperlink{namespacekeycpp_a6460fa334239dde761d8f737b9438fed}{keycpp\-::zaxpy\-\_\-} (const int $\ast$N, const std\-::complex$<$ double $>$ $\ast$alpha, const std\-::complex$<$ double $>$ $\ast$x, const int $\ast$incx, std\-::complex$<$ double $>$ $\ast$y, const int $\ast$incy)}\label{namespacekeycpp_a6460fa334239dde761d8f737b9438fed}

\begin{DoxyCompactList}\small\item\em This provides a C interface to B\-L\-A\-S's complex double vector addition function. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_a7d249dd978770119c1b91d88009fefbd}{void \hyperlink{namespacekeycpp_a7d249dd978770119c1b91d88009fefbd}{keycpp\-::dscal\-\_\-} (const int $\ast$N, const double $\ast$alpha, double $\ast$x, const int $\ast$incx)}\label{namespacekeycpp_a7d249dd978770119c1b91d88009fefbd}

\begin{DoxyCompactList}\small\item\em This provides a C interface to B\-L\-A\-S's double scalar-\/vector multiplication function. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_ad9dd69d0d355e4805a832813199f1dff}{void \hyperlink{namespacekeycpp_ad9dd69d0d355e4805a832813199f1dff}{keycpp\-::zscal\-\_\-} (const int $\ast$N, const std\-::complex$<$ double $>$ $\ast$alpha, std\-::complex$<$ double $>$ $\ast$x, const int $\ast$incx)}\label{namespacekeycpp_ad9dd69d0d355e4805a832813199f1dff}

\begin{DoxyCompactList}\small\item\em This provides a C interface to B\-L\-A\-S's complex double scalar-\/vector multiplication function. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_ace2501951ab3db3a91c3520ae89750b1}{void \hyperlink{namespacekeycpp_ace2501951ab3db3a91c3520ae89750b1}{keycpp\-::zggev\-\_\-} (const char $\ast$jobvl, const char $\ast$jobvr, const int $\ast$n, std\-::complex$<$ double $>$ $\ast$a, const int $\ast$lda, std\-::complex$<$ double $>$ $\ast$b, const int $\ast$ldb, std\-::complex$<$ double $>$ $\ast$alpha, std\-::complex$<$ double $>$ $\ast$beta, std\-::complex$<$ double $>$ $\ast$vl, const int $\ast$ldvl, std\-::complex$<$ double $>$ $\ast$vr, const int $\ast$ldvr, std\-::complex$<$ double $>$ $\ast$work, const int $\ast$lwork, double $\ast$rwork, int $\ast$info)}\label{namespacekeycpp_ace2501951ab3db3a91c3520ae89750b1}

\begin{DoxyCompactList}\small\item\em This provides a C interface to L\-A\-P\-A\-C\-K's complex generalized eigenvalue solver. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_aebc5253e80ac15a9bfdc5449ae4f972a}{void \hyperlink{namespacekeycpp_aebc5253e80ac15a9bfdc5449ae4f972a}{keycpp\-::dgeev\-\_\-} (const char $\ast$jobvl, const char $\ast$jobvr, const int $\ast$n, double $\ast$A, const int $\ast$lda, double $\ast$wr, double $\ast$wi, double $\ast$vl, const int $\ast$ldvl, double $\ast$vr, const int $\ast$ldvr, double $\ast$work, const int $\ast$lwork, int $\ast$info)}\label{namespacekeycpp_aebc5253e80ac15a9bfdc5449ae4f972a}

\begin{DoxyCompactList}\small\item\em This provides a C interface to L\-A\-P\-A\-C\-K's double precision eigenvalue solver for a general matrix. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_a8c1cca2a162f40fc6c6218c35cadf9f2}{void \hyperlink{namespacekeycpp_a8c1cca2a162f40fc6c6218c35cadf9f2}{keycpp\-::zgeev\-\_\-} (const char $\ast$jobvl, const char $\ast$, const int $\ast$n, std\-::complex$<$ double $>$ $\ast$A, const int $\ast$lda, std\-::complex$<$ double $>$ $\ast$w, std\-::complex$<$ double $>$ $\ast$V\-L, const int $\ast$ldvl, std\-::complex$<$ double $>$ $\ast$V\-R, const int $\ast$ldvr, std\-::complex$<$ double $>$ $\ast$work, const int $\ast$lwork, double $\ast$rwork, int $\ast$info)}\label{namespacekeycpp_a8c1cca2a162f40fc6c6218c35cadf9f2}

\begin{DoxyCompactList}\small\item\em This provides a C interface to L\-A\-P\-A\-C\-K's complex eigenvalue solver for a general matrix. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_aca3be6524e195662cbb74a810305e721}{void \hyperlink{namespacekeycpp_aca3be6524e195662cbb74a810305e721}{keycpp\-::dgecon\-\_\-} (const char $\ast$norm, const int $\ast$n, double $\ast$a, const int $\ast$lda, const double $\ast$anorm, double $\ast$rcond, double $\ast$work, int $\ast$iwork, int $\ast$info)}\label{namespacekeycpp_aca3be6524e195662cbb74a810305e721}

\begin{DoxyCompactList}\small\item\em This provides a C interface to L\-A\-P\-A\-C\-K's double precision reciprocal condition number estimator. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_a75e334ffaf1864d7191e9e0b64189783}{void \hyperlink{namespacekeycpp_a75e334ffaf1864d7191e9e0b64189783}{keycpp\-::dgetrf\-\_\-} (const int $\ast$m, const int $\ast$n, double $\ast$a, const int $\ast$lda, int $\ast$lpiv, int $\ast$info)}\label{namespacekeycpp_a75e334ffaf1864d7191e9e0b64189783}

\begin{DoxyCompactList}\small\item\em This provides a C interface to L\-A\-P\-A\-C\-K's double precision L\-U decomposition function. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_ab9c33788a2c083aa5738eda1fe62a261}{void \hyperlink{namespacekeycpp_ab9c33788a2c083aa5738eda1fe62a261}{keycpp\-::dgetrs\-\_\-} (const char $\ast$trans, int $\ast$n, int $\ast$nrhs, double $\ast$a, const int $\ast$lda, int $\ast$ipiv, double $\ast$b, int $\ast$ldb, int $\ast$info)}\label{namespacekeycpp_ab9c33788a2c083aa5738eda1fe62a261}

\begin{DoxyCompactList}\small\item\em This provides a C interface to L\-A\-P\-A\-C\-K's double precision L\-U solver. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_a4507ef954be960fec70ca0f93258d730}{double \hyperlink{namespacekeycpp_a4507ef954be960fec70ca0f93258d730}{keycpp\-::dlange\-\_\-} (const char $\ast$norm, const int $\ast$m, const int $\ast$n, const double $\ast$a, const int $\ast$lda, double $\ast$work)}\label{namespacekeycpp_a4507ef954be960fec70ca0f93258d730}

\begin{DoxyCompactList}\small\item\em This provides a C interface to L\-A\-P\-A\-C\-K's double precision norm function. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_a444e3cdc7e7929414370b6b50ea1218c}{void \hyperlink{namespacekeycpp_a444e3cdc7e7929414370b6b50ea1218c}{keycpp\-::zgecon\-\_\-} (const char $\ast$norm, const int $\ast$n, std\-::complex$<$ double $>$ $\ast$a, const int $\ast$lda, const double $\ast$anorm, double $\ast$rcond, std\-::complex$<$ double $>$ $\ast$work, double $\ast$rwork, int $\ast$info)}\label{namespacekeycpp_a444e3cdc7e7929414370b6b50ea1218c}

\begin{DoxyCompactList}\small\item\em This provides a C interface to L\-A\-P\-A\-C\-K's complex-\/valued reciprocal condition number estimator. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_ab18d58d53d8e19a37d74d24da27a64dd}{void \hyperlink{namespacekeycpp_ab18d58d53d8e19a37d74d24da27a64dd}{keycpp\-::zgetrf\-\_\-} (const int $\ast$m, const int $\ast$n, std\-::complex$<$ double $>$ $\ast$a, const int $\ast$lda, int $\ast$lpiv, int $\ast$info)}\label{namespacekeycpp_ab18d58d53d8e19a37d74d24da27a64dd}

\begin{DoxyCompactList}\small\item\em This provides a C interface to L\-A\-P\-A\-C\-K's complex L\-U decomposition function. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_abbe4322276dcdb7d864e85854b5b90f2}{void \hyperlink{namespacekeycpp_abbe4322276dcdb7d864e85854b5b90f2}{keycpp\-::zgetrs\-\_\-} (const char $\ast$trans, int $\ast$n, int $\ast$nrhs, std\-::complex$<$ double $>$ $\ast$a, const int $\ast$lda, int $\ast$ipiv, std\-::complex$<$ double $>$ $\ast$b, int $\ast$ldb, int $\ast$info)}\label{namespacekeycpp_abbe4322276dcdb7d864e85854b5b90f2}

\begin{DoxyCompactList}\small\item\em This provides a C interface to L\-A\-P\-A\-C\-K's complex L\-U solver. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_a1477c910b07baef984fe8528c29b2774}{double \hyperlink{namespacekeycpp_a1477c910b07baef984fe8528c29b2774}{keycpp\-::zlange\-\_\-} (const char $\ast$norm, const int $\ast$m, const int $\ast$n, const std\-::complex$<$ double $>$ $\ast$a, const int $\ast$lda, double $\ast$work)}\label{namespacekeycpp_a1477c910b07baef984fe8528c29b2774}

\begin{DoxyCompactList}\small\item\em This provides a C interface to L\-A\-P\-A\-C\-K's complex norm function. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_a12719f4b48de048f9642066666a920bd}{void \hyperlink{namespacekeycpp_a12719f4b48de048f9642066666a920bd}{keycpp\-::dgesv\-\_\-} (const int $\ast$n, const int $\ast$nrhs, double $\ast$a, const int $\ast$lda, int $\ast$ipiv, double $\ast$b, const int $\ast$ldb, const int $\ast$info)}\label{namespacekeycpp_a12719f4b48de048f9642066666a920bd}

\begin{DoxyCompactList}\small\item\em This provides a C interface to L\-A\-P\-A\-C\-K's double precision linear system solver. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_af92d0d887ae48cc4222f7167232a7f82}{void \hyperlink{namespacekeycpp_af92d0d887ae48cc4222f7167232a7f82}{keycpp\-::dgetri\-\_\-} (const int $\ast$n, double $\ast$A, const int $\ast$lda, const int $\ast$ipiv, double $\ast$work, const int $\ast$lwork, int $\ast$info)}\label{namespacekeycpp_af92d0d887ae48cc4222f7167232a7f82}

\begin{DoxyCompactList}\small\item\em This provides a C interface to L\-A\-P\-A\-C\-K's double precision matrix inverse function. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_a4190e125fe33133aafa586089ca6e174}{void \hyperlink{namespacekeycpp_a4190e125fe33133aafa586089ca6e174}{keycpp\-::zgetri\-\_\-} (const int $\ast$n, std\-::complex$<$ double $>$ $\ast$A, const int $\ast$lda, const int $\ast$ipiv, std\-::complex$<$ double $>$ $\ast$work, const int $\ast$lwork, int $\ast$info)}\label{namespacekeycpp_a4190e125fe33133aafa586089ca6e174}

\begin{DoxyCompactList}\small\item\em This provides a C interface to L\-A\-P\-A\-C\-K's complex matrix inverse function. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_a8fe7a71afbb6c5dc049cdd7afff6c0af}{void \hyperlink{namespacekeycpp_a8fe7a71afbb6c5dc049cdd7afff6c0af}{keycpp\-::dgesvd\-\_\-} (const char $\ast$jobu, const char $\ast$jobvt, const int $\ast$m, const int $\ast$n, double $\ast$A, const int $\ast$lda, double $\ast$S, double $\ast$U, const int $\ast$ldu, double $\ast$V\-T, const int $\ast$ldvt, double $\ast$work, const int $\ast$lwork, int $\ast$info)}\label{namespacekeycpp_a8fe7a71afbb6c5dc049cdd7afff6c0af}

\begin{DoxyCompactList}\small\item\em This provides a C interface to L\-A\-P\-A\-C\-K's double precision S\-V\-D function. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_afa5e2f74110f53bd288c15ce1f183f9b}{void \hyperlink{namespacekeycpp_afa5e2f74110f53bd288c15ce1f183f9b}{keycpp\-::zgesvd\-\_\-} (const char $\ast$jobu, const char $\ast$jobvt, const int $\ast$m, const int $\ast$n, std\-::complex$<$ double $>$ $\ast$A, const int $\ast$lda, double $\ast$S, std\-::complex$<$ double $>$ $\ast$U, const int $\ast$ldu, std\-::complex$<$ double $>$ $\ast$V\-T, const int $\ast$ldvt, std\-::complex$<$ double $>$ $\ast$work, const int $\ast$lwork, double $\ast$rwork, int $\ast$info)}\label{namespacekeycpp_afa5e2f74110f53bd288c15ce1f183f9b}

\begin{DoxyCompactList}\small\item\em This provides a C interface to L\-A\-P\-A\-C\-K's complex S\-V\-D function. \end{DoxyCompactList}\item 
matrix$<$ std\-::complex$<$ double $>$ $>$ \hyperlink{namespacekeycpp_aef2cabbae720e89202edc998eb6cbfec}{keycpp\-::eig} (const matrix$<$ std\-::complex$<$ double $>$ $>$ \&A, const matrix$<$ std\-::complex$<$ double $>$ $>$ \&B, matrix$<$ std\-::complex$<$ double $>$ $>$ $\ast$vr\-\_\-return, matrix$<$ std\-::complex$<$ double $>$ $>$ $\ast$vl\-\_\-return)
\begin{DoxyCompactList}\small\item\em Generalized complex-\/valued eigenvalue solver using L\-A\-P\-A\-C\-K function call. \end{DoxyCompactList}\item 
matrix$<$ std\-::complex$<$ double $>$ $>$ \hyperlink{namespacekeycpp_ae8be23e99e5aab35207275afc0d43a57}{keycpp\-::eig} (const matrix$<$ std\-::complex$<$ double $>$ $>$ \&A, matrix$<$ std\-::complex$<$ double $>$ $>$ $\ast$vr\-\_\-return, matrix$<$ std\-::complex$<$ double $>$ $>$ $\ast$vl\-\_\-return)
\begin{DoxyCompactList}\small\item\em Complex-\/valued eigenvalue solver using L\-A\-P\-A\-C\-K function call. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_a0634c813880b20cecb300509be839a94}{matrix$<$ std\-::complex$<$ double $>$ $>$ {\bfseries keycpp\-::eig} (const matrix$<$ double $>$ \&A, matrix$<$ std\-::complex$<$ double $>$$>$ $\ast$vr\-\_\-return=N\-U\-L\-L, matrix$<$ std\-::complex$<$ double $>$$>$ $\ast$vl\-\_\-return=N\-U\-L\-L)}\label{namespacekeycpp_a0634c813880b20cecb300509be839a94}

\item 
\hypertarget{namespacekeycpp_a3905cfc35dbd146f5dbf7bcb5729c2c2}{double {\bfseries keycpp\-::rcond} (const matrix$<$ double $>$ \&A)}\label{namespacekeycpp_a3905cfc35dbd146f5dbf7bcb5729c2c2}

\item 
\hypertarget{namespacekeycpp_a4d9a9dd04453e5a417f7a9eb8ae4391b}{double {\bfseries keycpp\-::rcond} (const matrix$<$ std\-::complex$<$ double $>$$>$ \&A)}\label{namespacekeycpp_a4d9a9dd04453e5a417f7a9eb8ae4391b}

\item 
\hypertarget{namespacekeycpp_a689c189f68e2b22b98c1f484c4d965e8}{matrix$<$ std\-::complex$<$ double $>$ $>$ {\bfseries keycpp\-::linsolve} (const matrix$<$ std\-::complex$<$ double $>$$>$ \&A\-\_\-in, const matrix$<$ std\-::complex$<$ double $>$$>$ \&b\-\_\-in)}\label{namespacekeycpp_a689c189f68e2b22b98c1f484c4d965e8}

\item 
\hypertarget{namespacekeycpp_a3246a259240624138144230f049e8dde}{matrix$<$ double $>$ {\bfseries keycpp\-::linsolve} (const matrix$<$ double $>$ \&A\-\_\-in, const matrix$<$ double $>$ \&b\-\_\-in)}\label{namespacekeycpp_a3246a259240624138144230f049e8dde}

\item 
\hypertarget{namespacekeycpp_adc96927cda2df7a6e8e2031941c43601}{matrix$<$ double $>$ {\bfseries keycpp\-::inv} (const matrix$<$ double $>$ \&A\-\_\-in)}\label{namespacekeycpp_adc96927cda2df7a6e8e2031941c43601}

\item 
\hypertarget{namespacekeycpp_a9085342fc708fd5babae39321da3b89a}{matrix$<$ std\-::complex$<$ double $>$ $>$ {\bfseries keycpp\-::inv} (const matrix$<$ std\-::complex$<$ double $>$$>$ \&A\-\_\-in)}\label{namespacekeycpp_a9085342fc708fd5babae39321da3b89a}

\item 
{\footnotesize template$<$class T , size\-\_\-t dim$>$ }\\matrix$<$ size\-\_\-t, 2 $>$ \hyperlink{namespacekeycpp_a3bffa5a846e181974d7bfe2ab41fe03a}{keycpp\-::size} (const matrix$<$ T, dim $>$ \&A)
\begin{DoxyCompactList}\small\item\em Returns the size of matrix A. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_ad91dbdf14632d313a304d3ddbadf935f}{{\footnotesize template$<$class T $>$ }\\bool \hyperlink{namespacekeycpp_ad91dbdf14632d313a304d3ddbadf935f}{keycpp\-::isnan} (const T \&a)}\label{namespacekeycpp_ad91dbdf14632d313a304d3ddbadf935f}

\begin{DoxyCompactList}\small\item\em Returns boolean value that is true if a is Na\-N. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_ad06706aa6f44dde4b12566f81ed2be94}{{\footnotesize template$<$$>$ }\\bool \hyperlink{namespacekeycpp_ad06706aa6f44dde4b12566f81ed2be94}{keycpp\-::isnan} (const std\-::complex$<$ double $>$ \&a)}\label{namespacekeycpp_ad06706aa6f44dde4b12566f81ed2be94}

\begin{DoxyCompactList}\small\item\em Returns boolean value that is true if a is Na\-N. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_a7e322f9a9b9a2bd3446ecaffbcea88cb}{{\footnotesize template$<$class T , size\-\_\-t dim$>$ }\\matrix$<$ bool, dim $>$ \hyperlink{namespacekeycpp_a7e322f9a9b9a2bd3446ecaffbcea88cb}{keycpp\-::isnan} (const matrix$<$ T, dim $>$ \&A)}\label{namespacekeycpp_a7e322f9a9b9a2bd3446ecaffbcea88cb}

\begin{DoxyCompactList}\small\item\em Returns matrix containing boolean values that are true if corresponding elements of A are Na\-N. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_ac999bd518fb456aa9a4fbd2c04f007de}{{\footnotesize template$<$class T , size\-\_\-t dim$>$ }\\matrix$<$ T, dim $>$ {\bfseries keycpp\-::eop} (const matrix$<$ T, dim $>$ \&A, T($\ast$f)(const T \&))}\label{namespacekeycpp_ac999bd518fb456aa9a4fbd2c04f007de}

\item 
\hypertarget{namespacekeycpp_a0865e2c884915d6ed0e3ef7bf73438b0}{{\footnotesize template$<$class T , size\-\_\-t dim$>$ }\\matrix$<$ T, dim $>$ {\bfseries keycpp\-::eop} (const matrix$<$ std\-::complex$<$ T $>$, dim $>$ \&A, T($\ast$f)(const std\-::complex$<$ T $>$ \&))}\label{namespacekeycpp_a0865e2c884915d6ed0e3ef7bf73438b0}

\item 
\hypertarget{namespacekeycpp_a46e135aeca12d58b9a084413bf571783}{{\footnotesize template$<$class T , size\-\_\-t dim$>$ }\\matrix$<$ T, dim $>$ {\bfseries keycpp\-::eop} (const matrix$<$ T, dim $>$ \&A, T($\ast$f)(T))}\label{namespacekeycpp_a46e135aeca12d58b9a084413bf571783}

\item 
\hypertarget{namespacekeycpp_a2309a6456fab18ec68a436f269d32d8f}{{\footnotesize template$<$class T , size\-\_\-t dim$>$ }\\matrix$<$ T, dim $>$ {\bfseries keycpp\-::eop} (const matrix$<$ std\-::complex$<$ T $>$, dim $>$ \&A, T($\ast$f)(std\-::complex$<$ T $>$))}\label{namespacekeycpp_a2309a6456fab18ec68a436f269d32d8f}

\item 
\hypertarget{namespacekeycpp_a86f8946c126102b4467b70da16766b7a}{{\footnotesize template$<$class T $>$ }\\std\-::ostream \& {\bfseries keycpp\-::operator$<$$<$} (std\-::ostream \&out, const vector\-\_\-k$<$ T $>$ \&v1)}\label{namespacekeycpp_a86f8946c126102b4467b70da16766b7a}

\item 
\hypertarget{namespacekeycpp_add55ad2a40111d6368744a3d4144f25a}{{\footnotesize template$<$class T $>$ }\\T \hyperlink{namespacekeycpp_add55ad2a40111d6368744a3d4144f25a}{keycpp\-::prod} (const vector\-\_\-k$<$ T $>$ \&x)}\label{namespacekeycpp_add55ad2a40111d6368744a3d4144f25a}

\begin{DoxyCompactList}\small\item\em Returns the product of all the elements of the vector x. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_af5471fc9074471701bde9e68eb7971b4}{{\footnotesize template$<$class T $>$ }\\vector\-\_\-k$<$ T $>$ \hyperlink{namespacekeycpp_af5471fc9074471701bde9e68eb7971b4}{keycpp\-::prod} (const matrix$<$ T $>$ \&A)}\label{namespacekeycpp_af5471fc9074471701bde9e68eb7971b4}

\begin{DoxyCompactList}\small\item\em Returns a vector containing the product of all the elements in each column of the matrix A. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_a52c37ec9c41349fd6bd862b8ebdd01bb}{{\footnotesize template$<$class T $>$ }\\vector\-\_\-k$<$ T $>$ \hyperlink{namespacekeycpp_a52c37ec9c41349fd6bd862b8ebdd01bb}{keycpp\-::diff} (const vector\-\_\-k$<$ T $>$ \&v1)}\label{namespacekeycpp_a52c37ec9c41349fd6bd862b8ebdd01bb}

\begin{DoxyCompactList}\small\item\em Returns a vector of differences between adjacent elements. \end{DoxyCompactList}\item 
{\footnotesize template$<$class T $>$ }\\matrix$<$ T $>$ \hyperlink{namespacekeycpp_abb4e57814fd30b7b8d4845bbc16c73e9}{keycpp\-::diff} (const matrix$<$ T $>$ \&A)
\begin{DoxyCompactList}\small\item\em Returns a matrix of row differences between adjacent rows. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_a422c63d9cf20e676efbcefd445698aca}{{\footnotesize template$<$class T , size\-\_\-t dim$>$ }\\matrix$<$ std\-::complex$<$ T $>$, dim $>$ {\bfseries keycpp\-::conj} (const matrix$<$ std\-::complex$<$ T $>$, dim $>$ \&A)}\label{namespacekeycpp_a422c63d9cf20e676efbcefd445698aca}

\item 
\hypertarget{namespacekeycpp_a6ab8937a6378526f7514c6124fb9991a}{{\footnotesize template$<$class T , size\-\_\-t dim$>$ }\\matrix$<$ T, dim $>$ {\bfseries keycpp\-::real} (const matrix$<$ std\-::complex$<$ T $>$, dim $>$ \&A)}\label{namespacekeycpp_a6ab8937a6378526f7514c6124fb9991a}

\item 
\hypertarget{namespacekeycpp_a026d42394a53ae81f292d1e3de4383cb}{{\footnotesize template$<$class T , size\-\_\-t dim$>$ }\\matrix$<$ T, dim $>$ {\bfseries keycpp\-::imag} (const matrix$<$ std\-::complex$<$ T $>$, dim $>$ \&A)}\label{namespacekeycpp_a026d42394a53ae81f292d1e3de4383cb}

\item 
\hypertarget{namespacekeycpp_aeaeb417b7e61b4bbe200edc1315c7d2e}{{\footnotesize template$<$class T , size\-\_\-t dim$>$ }\\matrix$<$ T, dim $>$ {\bfseries keycpp\-::abs} (const matrix$<$ T, dim $>$ \&A)}\label{namespacekeycpp_aeaeb417b7e61b4bbe200edc1315c7d2e}

\item 
\hypertarget{namespacekeycpp_a6f7d77410749bcf5a36793e3754e357b}{{\footnotesize template$<$class T , size\-\_\-t dim$>$ }\\matrix$<$ T, dim $>$ {\bfseries keycpp\-::abs} (const matrix$<$ std\-::complex$<$ T $>$, dim $>$ \&A)}\label{namespacekeycpp_a6f7d77410749bcf5a36793e3754e357b}

\item 
\hypertarget{namespacekeycpp_a952e5296774667c3be4e792b5cd980da}{std\-::complex$<$ double $>$ {\bfseries keycpp\-::csqrt} (const double \&a)}\label{namespacekeycpp_a952e5296774667c3be4e792b5cd980da}

\item 
\hypertarget{namespacekeycpp_a8faa7912f1f198c5185cb6a36cfd2fb2}{std\-::complex$<$ double $>$ {\bfseries keycpp\-::csqrt} (const std\-::complex$<$ double $>$ \&a)}\label{namespacekeycpp_a8faa7912f1f198c5185cb6a36cfd2fb2}

\item 
\hypertarget{namespacekeycpp_a18a3ebbda3c25527ae280f5c5725ff4e}{{\footnotesize template$<$class T , size\-\_\-t dim$>$ }\\matrix$<$ std\-::complex$<$ T $>$, dim $>$ \hyperlink{namespacekeycpp_a18a3ebbda3c25527ae280f5c5725ff4e}{keycpp\-::sin} (const matrix$<$ std\-::complex$<$ T $>$, dim $>$ \&A)}\label{namespacekeycpp_a18a3ebbda3c25527ae280f5c5725ff4e}

\begin{DoxyCompactList}\small\item\em Return a vector containing the sine of each element of A. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_aedb234b850e34f9331031d39084fdbb0}{{\footnotesize template$<$class T , size\-\_\-t dim$>$ }\\matrix$<$ T, dim $>$ \hyperlink{namespacekeycpp_aedb234b850e34f9331031d39084fdbb0}{keycpp\-::sin} (const matrix$<$ T, dim $>$ \&A)}\label{namespacekeycpp_aedb234b850e34f9331031d39084fdbb0}

\begin{DoxyCompactList}\small\item\em Return a vector containing the sine of each element of A. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_a918a1ad9493c25e0afb4d2a37af24d25}{{\footnotesize template$<$class T , size\-\_\-t dim$>$ }\\matrix$<$ std\-::complex$<$ T $>$, dim $>$ \hyperlink{namespacekeycpp_a918a1ad9493c25e0afb4d2a37af24d25}{keycpp\-::cos} (const matrix$<$ std\-::complex$<$ T $>$, dim $>$ \&A)}\label{namespacekeycpp_a918a1ad9493c25e0afb4d2a37af24d25}

\begin{DoxyCompactList}\small\item\em Return a vector containing the cosine of each element of A. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_a882ae0fcbeee4b61db0483546cf76021}{{\footnotesize template$<$class T , size\-\_\-t dim$>$ }\\matrix$<$ T, dim $>$ \hyperlink{namespacekeycpp_a882ae0fcbeee4b61db0483546cf76021}{keycpp\-::cos} (const matrix$<$ T, dim $>$ \&A)}\label{namespacekeycpp_a882ae0fcbeee4b61db0483546cf76021}

\begin{DoxyCompactList}\small\item\em Return a vector containing the cos of each element of A. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_a8e81f8ab9b05b8eaf07be99e141ce1c9}{{\footnotesize template$<$class T , size\-\_\-t dim$>$ }\\matrix$<$ std\-::complex$<$ T $>$, dim $>$ \hyperlink{namespacekeycpp_a8e81f8ab9b05b8eaf07be99e141ce1c9}{keycpp\-::tan} (const matrix$<$ std\-::complex$<$ T $>$, dim $>$ \&A)}\label{namespacekeycpp_a8e81f8ab9b05b8eaf07be99e141ce1c9}

\begin{DoxyCompactList}\small\item\em Return a vector containing the tangent of each element of A. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_a3af9d4ca9aedc999153a2dd305a6e95e}{{\footnotesize template$<$class T , size\-\_\-t dim$>$ }\\matrix$<$ T, dim $>$ \hyperlink{namespacekeycpp_a3af9d4ca9aedc999153a2dd305a6e95e}{keycpp\-::tan} (const matrix$<$ T, dim $>$ \&A)}\label{namespacekeycpp_a3af9d4ca9aedc999153a2dd305a6e95e}

\begin{DoxyCompactList}\small\item\em Return a vector containing the tangent of each element of A. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_a74731028e7d006f90426aff4547c82e1}{{\footnotesize template$<$class T , size\-\_\-t dim$>$ }\\matrix$<$ std\-::complex$<$ T $>$, dim $>$ \hyperlink{namespacekeycpp_a74731028e7d006f90426aff4547c82e1}{keycpp\-::acos} (const matrix$<$ std\-::complex$<$ T $>$, dim $>$ \&A)}\label{namespacekeycpp_a74731028e7d006f90426aff4547c82e1}

\begin{DoxyCompactList}\small\item\em Return a vector containing the arc cosine of each element of A. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_aa4671e6b0c2be8f6411419d4615b2442}{{\footnotesize template$<$class T , size\-\_\-t dim$>$ }\\matrix$<$ T, dim $>$ \hyperlink{namespacekeycpp_aa4671e6b0c2be8f6411419d4615b2442}{keycpp\-::acos} (const matrix$<$ T, dim $>$ \&A)}\label{namespacekeycpp_aa4671e6b0c2be8f6411419d4615b2442}

\begin{DoxyCompactList}\small\item\em Return a vector containing the arc cosine of each element of A. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_a024251803fe616d13f26978e2ebb10cf}{{\footnotesize template$<$class T , size\-\_\-t dim$>$ }\\matrix$<$ std\-::complex$<$ T $>$, dim $>$ \hyperlink{namespacekeycpp_a024251803fe616d13f26978e2ebb10cf}{keycpp\-::asin} (const matrix$<$ std\-::complex$<$ T $>$, dim $>$ \&A)}\label{namespacekeycpp_a024251803fe616d13f26978e2ebb10cf}

\begin{DoxyCompactList}\small\item\em Return a vector containing the arc sine of each element of A. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_af7cedb7bbe6ba4a4c6f87cff65c91298}{{\footnotesize template$<$class T , size\-\_\-t dim$>$ }\\matrix$<$ T, dim $>$ \hyperlink{namespacekeycpp_af7cedb7bbe6ba4a4c6f87cff65c91298}{keycpp\-::asin} (const matrix$<$ T, dim $>$ \&A)}\label{namespacekeycpp_af7cedb7bbe6ba4a4c6f87cff65c91298}

\begin{DoxyCompactList}\small\item\em Return a vector containing the arc sine of each element of A. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_a0302faeef7172f537f3473216c0cf33b}{{\footnotesize template$<$class T , size\-\_\-t dim$>$ }\\matrix$<$ std\-::complex$<$ T $>$, dim $>$ \hyperlink{namespacekeycpp_a0302faeef7172f537f3473216c0cf33b}{keycpp\-::exp} (const matrix$<$ std\-::complex$<$ T $>$, dim $>$ \&A)}\label{namespacekeycpp_a0302faeef7172f537f3473216c0cf33b}

\begin{DoxyCompactList}\small\item\em Return a vector containing the exponential of each element of A. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_a89087f62a5d5d136ad88493b920953ac}{{\footnotesize template$<$class T , size\-\_\-t dim$>$ }\\matrix$<$ T, dim $>$ \hyperlink{namespacekeycpp_a89087f62a5d5d136ad88493b920953ac}{keycpp\-::exp} (const matrix$<$ T, dim $>$ \&A)}\label{namespacekeycpp_a89087f62a5d5d136ad88493b920953ac}

\begin{DoxyCompactList}\small\item\em Return a vector containing the exponential of each element of A. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_a0d31321365987f3cadb5e6d3038d2ff6}{{\footnotesize template$<$class T , size\-\_\-t dim$>$ }\\matrix$<$ std\-::complex$<$ T $>$, dim $>$ \hyperlink{namespacekeycpp_a0d31321365987f3cadb5e6d3038d2ff6}{keycpp\-::log} (const matrix$<$ std\-::complex$<$ T $>$, dim $>$ \&A)}\label{namespacekeycpp_a0d31321365987f3cadb5e6d3038d2ff6}

\begin{DoxyCompactList}\small\item\em Return a vector containing the natural logarithm of each element of A. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_a7a235af8108964defc4dc084bec2c7f9}{{\footnotesize template$<$class T , size\-\_\-t dim$>$ }\\matrix$<$ T, dim $>$ \hyperlink{namespacekeycpp_a7a235af8108964defc4dc084bec2c7f9}{keycpp\-::log} (const matrix$<$ T, dim $>$ \&A)}\label{namespacekeycpp_a7a235af8108964defc4dc084bec2c7f9}

\begin{DoxyCompactList}\small\item\em Return a vector containing the natural logarithm of each element of A. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_af5ee080f280e09a893944b33683e3d4d}{{\footnotesize template$<$class T , size\-\_\-t dim$>$ }\\matrix$<$ std\-::complex$<$ T $>$, dim $>$ \hyperlink{namespacekeycpp_af5ee080f280e09a893944b33683e3d4d}{keycpp\-::log10} (const matrix$<$ std\-::complex$<$ T $>$, dim $>$ \&A)}\label{namespacekeycpp_af5ee080f280e09a893944b33683e3d4d}

\begin{DoxyCompactList}\small\item\em Return a vector containing the base 10 logarithm of each element of A. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_a3e6fb67c965ed61d53e3438a65282b97}{{\footnotesize template$<$class T , size\-\_\-t dim$>$ }\\matrix$<$ T, dim $>$ \hyperlink{namespacekeycpp_a3e6fb67c965ed61d53e3438a65282b97}{keycpp\-::log10} (const matrix$<$ T, dim $>$ \&A)}\label{namespacekeycpp_a3e6fb67c965ed61d53e3438a65282b97}

\begin{DoxyCompactList}\small\item\em Return a vector containing the base 10 logarithm of each element of A. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_a28a50cdc90b4c6f56bf9a7c144c4ac95}{{\footnotesize template$<$class T , size\-\_\-t dim$>$ }\\matrix$<$ std\-::complex$<$ T $>$, dim $>$ \hyperlink{namespacekeycpp_a28a50cdc90b4c6f56bf9a7c144c4ac95}{keycpp\-::sqrt} (const matrix$<$ std\-::complex$<$ T $>$, dim $>$ \&A)}\label{namespacekeycpp_a28a50cdc90b4c6f56bf9a7c144c4ac95}

\begin{DoxyCompactList}\small\item\em Return a vector containing the sqrt of each element of A. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_a1c9bd9044cff082d4bb16bf36903ca2f}{{\footnotesize template$<$class T , size\-\_\-t dim$>$ }\\matrix$<$ T, dim $>$ \hyperlink{namespacekeycpp_a1c9bd9044cff082d4bb16bf36903ca2f}{keycpp\-::sqrt} (const matrix$<$ T, dim $>$ \&A)}\label{namespacekeycpp_a1c9bd9044cff082d4bb16bf36903ca2f}

\begin{DoxyCompactList}\small\item\em Return a vector containing the sqrt of each element of A. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_ae86dd983e0f6ac12811b765d7cb68f68}{{\footnotesize template$<$class T , size\-\_\-t dim$>$ }\\matrix$<$ std\-::complex$<$ T $>$, dim $>$ \hyperlink{namespacekeycpp_ae86dd983e0f6ac12811b765d7cb68f68}{keycpp\-::csqrt} (const matrix$<$ std\-::complex$<$ T $>$, dim $>$ \&A)}\label{namespacekeycpp_ae86dd983e0f6ac12811b765d7cb68f68}

\begin{DoxyCompactList}\small\item\em Return a vector containing the csqrt of each element of A. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_a7ac11afedab6d33ab5c6bf7e7f7c7a32}{{\footnotesize template$<$class T , size\-\_\-t dim$>$ }\\matrix$<$ T, dim $>$ \hyperlink{namespacekeycpp_a7ac11afedab6d33ab5c6bf7e7f7c7a32}{keycpp\-::csqrt} (const matrix$<$ T, dim $>$ \&A)}\label{namespacekeycpp_a7ac11afedab6d33ab5c6bf7e7f7c7a32}

\begin{DoxyCompactList}\small\item\em Return a vector containing the csqrt of each element of A. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_a8ae33fb19a521ab1ec1f22e7c39ca076}{{\footnotesize template$<$class T $>$ }\\matrix$<$ T $>$ {\bfseries keycpp\-::eye} (const int \&N)}\label{namespacekeycpp_a8ae33fb19a521ab1ec1f22e7c39ca076}

\item 
{\footnotesize template$<$class T , size\-\_\-t dim$>$ }\\int \hyperlink{namespacekeycpp_a737223780bc4bcda96ca2142a2ac3de9}{keycpp\-::size} (const matrix$<$ T, dim $>$ \&A, const int \&n)
\begin{DoxyCompactList}\small\item\em Returns the number of elements along dimension dim. \end{DoxyCompactList}\item 
{\footnotesize template$<$class T $>$ }\\matrix$<$ T $>$ \hyperlink{namespacekeycpp_a5699c522088657287bf0ac01173b716c}{keycpp\-::zeros} (const int \&M, const int \&N)
\begin{DoxyCompactList}\small\item\em Returns a matrix of size M x N containing all zeros. \end{DoxyCompactList}\item 
{\footnotesize template$<$class T $>$ }\\matrix$<$ T, 2 $>$ \hyperlink{namespacekeycpp_a3f2d2688097884d279a27fdbb38d35b6}{keycpp\-::zeros} (const int \&N)
\begin{DoxyCompactList}\small\item\em Returns a matrix of size N x N containing all zeros. \end{DoxyCompactList}\item 
{\footnotesize template$<$class T $>$ }\\matrix$<$ T $>$ \hyperlink{namespacekeycpp_a388f91a0ccf34978ef9403ccd0c680bf}{keycpp\-::ones} (const int \&M, const int \&N)
\begin{DoxyCompactList}\small\item\em Returns a matrix of size M x N containing all ones. \end{DoxyCompactList}\item 
{\footnotesize template$<$class T $>$ }\\matrix$<$ T, 2 $>$ \hyperlink{namespacekeycpp_a49b117efdb07f136f72534b65952c167}{keycpp\-::ones} (const int \&N)
\begin{DoxyCompactList}\small\item\em Returns a matrix of size N x N containing all ones. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_a4bb3ea9a842383b82c889179f25be9ec}{{\footnotesize template$<$class T $>$ }\\matrix$<$ T $>$ {\bfseries keycpp\-::diag} (const std\-::initializer\-\_\-list$<$ T $>$ \&lst, const int \&d=0)}\label{namespacekeycpp_a4bb3ea9a842383b82c889179f25be9ec}

\item 
\hypertarget{namespacekeycpp_abb22f2e817f5a19a8547f446d48855b6}{{\footnotesize template$<$class T $>$ }\\matrix$<$ T, 2 $>$ {\bfseries keycpp\-::diag} (const matrix$<$ T, 2 $>$ \&A, const int \&d=0)}\label{namespacekeycpp_abb22f2e817f5a19a8547f446d48855b6}

\item 
\hypertarget{namespacekeycpp_a7dec07979cca186806a17250b2cb50aa}{{\footnotesize template$<$class T $>$ }\\matrix$<$ T, 2 $>$ {\bfseries keycpp\-::repmat} (const matrix$<$ T, 2 $>$ \&A, const int \&m, const int \&n)}\label{namespacekeycpp_a7dec07979cca186806a17250b2cb50aa}

\item 
{\footnotesize template$<$class T , class U , size\-\_\-t dim$>$ }\\matrix$<$ decltype(std\-::declval\\*
$<$ T $>$)$\ast$std\-::declval$<$ U $>$\\*
)), dim $>$ \hyperlink{namespacekeycpp_a23a0fd48168263aad7f77f1769dc2f2a}{keycpp\-::times} (const matrix$<$ T, dim $>$ \&A, const matrix$<$ U, dim $>$ \&B)
\begin{DoxyCompactList}\small\item\em Performs array multiplication on matrices A and B. \end{DoxyCompactList}\item 
{\footnotesize template$<$class T , class U , size\-\_\-t dim$>$ }\\matrix$<$ decltype(std\-::declval\\*
$<$ T $>$)$\ast$std\-::declval$<$ U $>$\\*
)), dim $>$ \hyperlink{namespacekeycpp_a6d379c0b2c9d430f498daae5601f7a79}{keycpp\-::rdivide} (const matrix$<$ T, dim $>$ \&A, const matrix$<$ U, dim $>$ \&B)
\begin{DoxyCompactList}\small\item\em Performs right array division on matrices A and B. \end{DoxyCompactList}\item 
{\footnotesize template$<$class T , class U $>$ }\\matrix$<$ decltype(std\-::declval\\*
$<$ T $>$)$\ast$std\-::declval$<$ U $>$))$>$ \hyperlink{namespacekeycpp_ac57d32902cba2c399475015235aeccec}{keycpp\-::ldivide} (const matrix$<$ T $>$ \&B, const matrix$<$ U $>$ \&A)
\begin{DoxyCompactList}\small\item\em Performs left array division on matrices B and A. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_a87f2917e6a7c8e20d010aea0d8480668}{{\footnotesize template$<$class T $>$ }\\int {\bfseries keycpp\-::sign} (const T \&val)}\label{namespacekeycpp_a87f2917e6a7c8e20d010aea0d8480668}

\item 
\hypertarget{namespacekeycpp_aaa2e17334911e8a447a5ef6c0cc54c3f}{{\footnotesize template$<$class T $>$ }\\T {\bfseries keycpp\-::angle} (const std\-::complex$<$ T $>$ \&x)}\label{namespacekeycpp_aaa2e17334911e8a447a5ef6c0cc54c3f}

\item 
\hypertarget{namespacekeycpp_afbbe373666d686c14e6ce6517d050373}{{\footnotesize template$<$class T , size\-\_\-t dim$>$ }\\matrix$<$ T, dim $>$ {\bfseries keycpp\-::angle} (const matrix$<$ std\-::complex$<$ T $>$, dim $>$ \&A)}\label{namespacekeycpp_afbbe373666d686c14e6ce6517d050373}

\item 
\hypertarget{namespacekeycpp_a03b5a8f06ace0e74416f6b22fbefd1a0}{{\footnotesize template$<$class T $>$ }\\matrix$<$ T, 2 $>$ {\bfseries keycpp\-::max} (const matrix$<$ T, 2 $>$ \&A)}\label{namespacekeycpp_a03b5a8f06ace0e74416f6b22fbefd1a0}

\item 
\hypertarget{namespacekeycpp_adafc954673ba1f1fb140d83ba1d88a23}{matrix$<$ std\-::complex$<$ double $>$, 2 $>$ {\bfseries keycpp\-::max} (const matrix$<$ std\-::complex$<$ double $>$, 2 $>$ \&A)}\label{namespacekeycpp_adafc954673ba1f1fb140d83ba1d88a23}

\item 
\hypertarget{namespacekeycpp_a96f9dd276a27f616258da602ee559541}{{\footnotesize template$<$class T $>$ }\\matrix$<$ T, 2 $>$ {\bfseries keycpp\-::min} (const matrix$<$ T, 2 $>$ \&A)}\label{namespacekeycpp_a96f9dd276a27f616258da602ee559541}

\item 
\hypertarget{namespacekeycpp_aa29add9ed4a57360a11fbf614df7f3a7}{matrix$<$ std\-::complex$<$ double $>$, 2 $>$ {\bfseries keycpp\-::min} (const matrix$<$ std\-::complex$<$ double $>$, 2 $>$ \&A)}\label{namespacekeycpp_aa29add9ed4a57360a11fbf614df7f3a7}

\item 
\hypertarget{namespacekeycpp_a7fd5ce0385e9cc7bed5b44ed8475e8aa}{{\footnotesize template$<$class T $>$ }\\matrix$<$ T $>$ \hyperlink{namespacekeycpp_a7fd5ce0385e9cc7bed5b44ed8475e8aa}{keycpp\-::transpose} (const matrix$<$ T $>$ \&A)}\label{namespacekeycpp_a7fd5ce0385e9cc7bed5b44ed8475e8aa}

\begin{DoxyCompactList}\small\item\em Returns the transpose of matrix A. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_a14503c0419f365433d88fa081d473210}{{\footnotesize template$<$class T $>$ }\\matrix$<$ T $>$ \hyperlink{namespacekeycpp_a14503c0419f365433d88fa081d473210}{keycpp\-::ctranspose} (const matrix$<$ T $>$ \&A)}\label{namespacekeycpp_a14503c0419f365433d88fa081d473210}

\begin{DoxyCompactList}\small\item\em Returns the complex-\/conjugate transpose of matrix A. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_a9fc1e2c9bf6ee79ee28a6f25b7b55b23}{{\footnotesize template$<$$>$ }\\matrix$<$ double $>$ \hyperlink{namespacekeycpp_a9fc1e2c9bf6ee79ee28a6f25b7b55b23}{keycpp\-::ctranspose$<$ double $>$} (const matrix$<$ double $>$ \&A)}\label{namespacekeycpp_a9fc1e2c9bf6ee79ee28a6f25b7b55b23}

\begin{DoxyCompactList}\small\item\em Returns the complex-\/conjugate transpose of matrix A. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_a36cda317c047e8579e665abccf1b1398}{{\footnotesize template$<$class T $>$ }\\matrix$<$ T, 2 $>$ \hyperlink{namespacekeycpp_a36cda317c047e8579e665abccf1b1398}{keycpp\-::sum} (const matrix$<$ T, 2 $>$ \&A)}\label{namespacekeycpp_a36cda317c047e8579e665abccf1b1398}

\begin{DoxyCompactList}\small\item\em Computes the sum of each column of A. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_a4b8772b4517093ae5e6de3261ded005d}{{\footnotesize template$<$class T $>$ }\\matrix$<$ T, 2 $>$ {\bfseries keycpp\-::linspace} (const T \&x1, const T \&x2, const size\-\_\-t \&N)}\label{namespacekeycpp_a4b8772b4517093ae5e6de3261ded005d}

\item 
{\footnotesize template$<$class T $>$ }\\matrix$<$ T, 2 $>$ \hyperlink{namespacekeycpp_a28626d0ffc4ecda3f9bc6e7b0f4fc4d2}{keycpp\-::logspace} (const T \&x1, const T \&x2, const int \&N)
\begin{DoxyCompactList}\small\item\em Produces a vector containing N values logarithmically spaced between 10$^\wedge$(x1) and 10$^\wedge$(x2), inclusively. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_aec240358cae3ca4a4a92c9e7dead409c}{{\footnotesize template$<$class T $>$ }\\matrix$<$ T, 2 $>$ {\bfseries keycpp\-::unwrap} (const matrix$<$ T, 2 $>$ \&v1, const T \&tol=pi)}\label{namespacekeycpp_aec240358cae3ca4a4a92c9e7dead409c}

\item 
\hypertarget{namespacekeycpp_a24ef7ec1e4c2fab43922859a44758da6}{{\footnotesize template$<$class T $>$ }\\T \hyperlink{namespacekeycpp_a24ef7ec1e4c2fab43922859a44758da6}{keycpp\-::mean} (const matrix$<$ T, 2 $>$ \&v1)}\label{namespacekeycpp_a24ef7ec1e4c2fab43922859a44758da6}

\begin{DoxyCompactList}\small\item\em Computes the mean of vector v1. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_a9c5f11c2b7a3890a0987b9dd10e31cd4}{{\footnotesize template$<$class T , class U $>$ }\\T {\bfseries keycpp\-::interp1\-\_\-vec} (const matrix$<$ U, 2 $>$ \&x, const matrix$<$ T, 2 $>$ \&y, const U \&x\-\_\-interp, std\-::string method=\char`\"{}linear\char`\"{}, Extrap extrap=Extrap())}\label{namespacekeycpp_a9c5f11c2b7a3890a0987b9dd10e31cd4}

\item 
\hypertarget{namespacekeycpp_ab452328f21ddc3131c2df2b3cbbbed7c}{{\footnotesize template$<$class T , class U $>$ }\\matrix$<$ T, 2 $>$ {\bfseries keycpp\-::interp1} (const matrix$<$ U, 2 $>$ \&x, const matrix$<$ T, 2 $>$ \&y, const matrix$<$ U, 2 $>$ \&x\-\_\-interp, std\-::string method=\char`\"{}linear\char`\"{}, Extrap extrap=Extrap())}\label{namespacekeycpp_ab452328f21ddc3131c2df2b3cbbbed7c}

\item 
\hypertarget{namespacekeycpp_aa379fd1b7ae981ede575baf357c18302}{{\footnotesize template$<$class T , class U $>$ }\\matrix$<$ T, 2 $>$ {\bfseries keycpp\-::interp1} (const matrix$<$ U, 2 $>$ \&x, const matrix$<$ T, 2 $>$ \&y, const U \&x\-\_\-interp, std\-::string method=\char`\"{}linear\char`\"{}, Extrap extrap=Extrap())}\label{namespacekeycpp_aa379fd1b7ae981ede575baf357c18302}

\item 
\hypertarget{namespacekeycpp_ac9e68fc6f023bc2634c3a6f1ddb7e6b8}{{\footnotesize template$<$class U , class T $>$ }\\matrix$<$ T, 2 $>$ {\bfseries keycpp\-::trapz} (const matrix$<$ U, 2 $>$ \&eta, const matrix$<$ T, 2 $>$ \&integrand)}\label{namespacekeycpp_ac9e68fc6f023bc2634c3a6f1ddb7e6b8}

\item 
\hypertarget{namespacekeycpp_adbb28bb59e9e552598c05ebe9d1af397}{{\footnotesize template$<$class T , class U $>$ }\\matrix$<$ T, 2 $>$ {\bfseries keycpp\-::diffxy} (const matrix$<$ U, 2 $>$ \&eta, const matrix$<$ T, 2 $>$ \&u, const int \&index=2)}\label{namespacekeycpp_adbb28bb59e9e552598c05ebe9d1af397}

\item 
\hypertarget{namespacekeycpp_a1fcfb748997291434fe9db7dbffd8c6f}{{\footnotesize template$<$class T $>$ }\\matrix$<$ std\-::complex$<$ double $>$, 2 $>$ {\bfseries keycpp\-::fft} (const matrix$<$ T, 2 $>$ \&u, int N=-\/1)}\label{namespacekeycpp_a1fcfb748997291434fe9db7dbffd8c6f}

\item 
\hypertarget{namespacekeycpp_a6d7114f640a4a253a1d50ffc810bdad0}{{\footnotesize template$<$class T , class U , class F $>$ }\\O\-D\-E\-\_\-type$<$ U, T $>$ {\bfseries keycpp\-::ode45} (F ode\-Class, const std\-::initializer\-\_\-list$<$ U $>$ \&x\-\_\-span, matrix$<$ T, 2 $>$ I\-Cs, double abs\-\_\-tol=1.\-0e-\/10, double rel\-\_\-tol=1.\-0e-\/6)}\label{namespacekeycpp_a6d7114f640a4a253a1d50ffc810bdad0}

\item 
\hypertarget{namespacekeycpp_aeea0edbbd76794e73bfade1d428f5dd7}{{\footnotesize template$<$class T , class U , class F $>$ }\\matrix$<$ T $>$ {\bfseries keycpp\-::ode45} (F ode\-Class, matrix$<$ U, 2 $>$ x\-\_\-ode, matrix$<$ T, 2 $>$ I\-Cs, double abs\-\_\-tol=1.\-0e-\/10, double rel\-\_\-tol=1.\-0e-\/6)}\label{namespacekeycpp_aeea0edbbd76794e73bfade1d428f5dd7}

\item 
\hypertarget{namespacekeycpp_afcd6ae07fc18f5374868fe314f00108c}{void {\bfseries keycpp\-::set} (Figure \&h, std\-::string property, double val)}\label{namespacekeycpp_afcd6ae07fc18f5374868fe314f00108c}

\item 
\hypertarget{namespacekeycpp_a53fd8f41e3cdddb0dcca913eef5ee329}{void {\bfseries keycpp\-::set} (Figure \&h, std\-::string property, std\-::string val)}\label{namespacekeycpp_a53fd8f41e3cdddb0dcca913eef5ee329}

\item 
\hypertarget{namespacekeycpp_ae67eb981ff22ef79a4ee90a9a40ae21f}{void {\bfseries keycpp\-::set} (Figure \&h, std\-::string property, std\-::initializer\-\_\-list$<$ size\-\_\-t $>$ list)}\label{namespacekeycpp_ae67eb981ff22ef79a4ee90a9a40ae21f}

\item 
\hypertarget{namespacekeycpp_af9dec3da4533a1db21a6c6c4fe8e740a}{void {\bfseries keycpp\-::print} (Figure \&h, std\-::string pterm, std\-::string pfilename)}\label{namespacekeycpp_af9dec3da4533a1db21a6c6c4fe8e740a}

\item 
\hypertarget{namespacekeycpp_a82fb697518c456560dea0b328e693418}{{\footnotesize template$<$class T $>$ }\\Sort\-\_\-\-Matrix$<$ T $>$ {\bfseries keycpp\-::sort} (const matrix$<$ T $>$ \&A, const size\-\_\-t \&dim=2, std\-::string method=\char`\"{}ascend\char`\"{})}\label{namespacekeycpp_a82fb697518c456560dea0b328e693418}

\item 
\hypertarget{namespacekeycpp_af4a2245da139cf6cf2e03426476b3b88}{{\footnotesize template$<$class T $>$ }\\void \hyperlink{namespacekeycpp_af4a2245da139cf6cf2e03426476b3b88}{keycpp\-::disp} (const T \&x, std\-::ostream \&out\-Stream=std\-::cout)}\label{namespacekeycpp_af4a2245da139cf6cf2e03426476b3b88}

\begin{DoxyCompactList}\small\item\em Displays on standard output any parameter passed to it provided the operator $<$$<$ is defined for its type. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_aba69db64fe38ad271de1939d3f1a5520}{std\-::string \hyperlink{namespacekeycpp_aba69db64fe38ad271de1939d3f1a5520}{keycpp\-::input} (const std\-::string \&prompt, std\-::string option)}\label{namespacekeycpp_aba69db64fe38ad271de1939d3f1a5520}

\begin{DoxyCompactList}\small\item\em Prints the prompt to the screen and then waits for user input. Currently the option must be supplied as \char`\"{}s\char`\"{} because C++ is a statically typed language. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_a4bca7924aad17a920f2f5f0606e6d9a9}{double \hyperlink{namespacekeycpp_a4bca7924aad17a920f2f5f0606e6d9a9}{keycpp\-::str2num} (const std\-::string \&in)}\label{namespacekeycpp_a4bca7924aad17a920f2f5f0606e6d9a9}

\begin{DoxyCompactList}\small\item\em Converts a std\-::string to a double. Currently only works on single numbers. In the future this should be expanded to work on vectors and matrices. (see M\-A\-T\-L\-A\-B docs) \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_a9c30ad952d4422425a171c12bdf33947}{{\footnotesize template$<$class T $>$ }\\size\-\_\-t \hyperlink{namespacekeycpp_a9c30ad952d4422425a171c12bdf33947}{keycpp\-::length} (const matrix$<$ T $>$ \&A)}\label{namespacekeycpp_a9c30ad952d4422425a171c12bdf33947}

\begin{DoxyCompactList}\small\item\em Returns the length of the largest dimension of A. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_adcbcd3d38aa0721f2556422eb06cad7d}{{\footnotesize template$<$class T $>$ }\\size\-\_\-t {\bfseries keycpp\-::numel} (const matrix$<$ T $>$ \&A)}\label{namespacekeycpp_adcbcd3d38aa0721f2556422eb06cad7d}

\item 
\hypertarget{namespacekeycpp_a1ff2731f68b07dddedc5d572a409ba9e}{{\footnotesize template$<$class T , size\-\_\-t dim$>$ }\\matrix$<$ size\-\_\-t, 2 $>$ \hyperlink{namespacekeycpp_a1ff2731f68b07dddedc5d572a409ba9e}{keycpp\-::find} (const matrix$<$ T, dim $>$ \&v1, const size\-\_\-t \&k=-\/1, std\-::string start=\char`\"{}\char`\"{})}\label{namespacekeycpp_a1ff2731f68b07dddedc5d572a409ba9e}

\begin{DoxyCompactList}\small\item\em Finds and returns the indices of non-\/zero elements of v1. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_a8e6462a878df6e022bd4f9aa6f953983}{{\footnotesize template$<$class T $>$ }\\matrix$<$ T $>$ {\bfseries keycpp\-::reshape} (const matrix$<$ T $>$ \&A, const size\-\_\-t \&m, const size\-\_\-t \&n)}\label{namespacekeycpp_a8e6462a878df6e022bd4f9aa6f953983}

\item 
\hypertarget{namespacekeycpp_a67c6ec70ba46d1d830acf7fbf8b8b97e}{{\footnotesize template$<$class T , class U $>$ }\\matrix$<$ decltype(std\-::declval\\*
$<$ T $>$)$\ast$std\-::declval$<$ U $>$))$>$ \hyperlink{namespacekeycpp_a67c6ec70ba46d1d830acf7fbf8b8b97e}{keycpp\-::dot} (const matrix$<$ T $>$ \&A, const matrix$<$ U $>$ \&B, const size\-\_\-t \&dim=-\/1)}\label{namespacekeycpp_a67c6ec70ba46d1d830acf7fbf8b8b97e}

\begin{DoxyCompactList}\small\item\em Computes the dot product between the first non-\/singleton dimension of A and B. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_a157ec9804a57367b3153fb3cc81f9224}{{\footnotesize template$<$class T , class U $>$ }\\matrix$<$ decltype(std\-::declval\\*
$<$ T $>$)$\ast$std\-::declval$<$ U $>$))$>$ \hyperlink{namespacekeycpp_a157ec9804a57367b3153fb3cc81f9224}{keycpp\-::cross} (const matrix$<$ T $>$ \&v1, const matrix$<$ U $>$ \&v2)}\label{namespacekeycpp_a157ec9804a57367b3153fb3cc81f9224}

\begin{DoxyCompactList}\small\item\em Computes the cross product between vectors v1 and v2. Both vectors must have exactly 3 elements. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_af6ba102c379ceaa8bfa814ecfa095a56}{double {\bfseries keycpp\-::norm} (const matrix$<$ double, 2, 0 $>$ \&A\-\_\-in, std\-::string method=\char`\"{}2\char`\"{})}\label{namespacekeycpp_af6ba102c379ceaa8bfa814ecfa095a56}

\item 
\hypertarget{namespacekeycpp_a838fc93d66e1ab63d68d04781086d81a}{S\-V\-D\-\_\-type$<$ double, double $>$ \hyperlink{namespacekeycpp_a838fc93d66e1ab63d68d04781086d81a}{keycpp\-::svd} (const matrix$<$ double $>$ \&A\-\_\-in, std\-::string method)}\label{namespacekeycpp_a838fc93d66e1ab63d68d04781086d81a}

\begin{DoxyCompactList}\small\item\em Computes the singular value decomposition of matrix A\-\_\-in. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_a3d00bd96e42ccdc9faabc117b829f325}{double {\bfseries keycpp\-::norm} (const matrix$<$ std\-::complex$<$ double $>$, 2, 0 $>$ \&A\-\_\-in, std\-::string method=\char`\"{}2\char`\"{})}\label{namespacekeycpp_a3d00bd96e42ccdc9faabc117b829f325}

\item 
\hypertarget{namespacekeycpp_ad610adca37ac4c85df23b899d29d5dfc}{S\-V\-D\-\_\-type$<$ std\-::complex$<$ double $>$\\*
, double $>$ \hyperlink{namespacekeycpp_ad610adca37ac4c85df23b899d29d5dfc}{keycpp\-::svd} (const matrix$<$ std\-::complex$<$ double $>$$>$ \&A\-\_\-in, std\-::string method)}\label{namespacekeycpp_ad610adca37ac4c85df23b899d29d5dfc}

\begin{DoxyCompactList}\small\item\em Computes the singular value decomposition of matrix A\-\_\-in. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_aeb9efbc77cc58fa22403ea7ae5f4555c}{{\footnotesize template$<$class T $>$ }\\int \hyperlink{namespacekeycpp_aeb9efbc77cc58fa22403ea7ae5f4555c}{keycpp\-::rank} (const matrix$<$ T $>$ \&A)}\label{namespacekeycpp_aeb9efbc77cc58fa22403ea7ae5f4555c}

\begin{DoxyCompactList}\small\item\em Estimates the rank of a matrix by counting the singular values whose absolute value is greater than epsilon. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_a8f497e2da901adba0e1257be943595a1}{{\footnotesize template$<$class T $>$ }\\matrix$<$ T $>$ \hyperlink{namespacekeycpp_a8f497e2da901adba0e1257be943595a1}{keycpp\-::null} (const matrix$<$ T $>$ \&A)}\label{namespacekeycpp_a8f497e2da901adba0e1257be943595a1}

\begin{DoxyCompactList}\small\item\em Computes the nullspace of matrix A. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_a70b89ab3e8f66f86c47c3bde004d4487}{{\footnotesize template$<$class T $>$ }\\bool \hyperlink{namespacekeycpp_a70b89ab3e8f66f86c47c3bde004d4487}{keycpp\-::any} (const T \&a)}\label{namespacekeycpp_a70b89ab3e8f66f86c47c3bde004d4487}

\begin{DoxyCompactList}\small\item\em Returns true if a is nonzero. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_a7c36622975d56232740753ada20b9f86}{{\footnotesize template$<$class T , size\-\_\-t dim$>$ }\\bool \hyperlink{namespacekeycpp_a7c36622975d56232740753ada20b9f86}{keycpp\-::any} (const matrix$<$ T, dim $>$ \&A)}\label{namespacekeycpp_a7c36622975d56232740753ada20b9f86}

\begin{DoxyCompactList}\small\item\em Returns true if any elements of A are nonzero. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_aab77d82d9cc7d1fcca87967048f09e0e}{{\footnotesize template$<$class T $>$ }\\bool \hyperlink{namespacekeycpp_aab77d82d9cc7d1fcca87967048f09e0e}{keycpp\-::all} (const T \&a)}\label{namespacekeycpp_aab77d82d9cc7d1fcca87967048f09e0e}

\begin{DoxyCompactList}\small\item\em Returns true if a is nonzero. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_a30bc3707493ba61f2165a189e7cbafd4}{{\footnotesize template$<$class T , size\-\_\-t dim$>$ }\\bool \hyperlink{namespacekeycpp_a30bc3707493ba61f2165a189e7cbafd4}{keycpp\-::all} (const matrix$<$ T, dim $>$ \&A)}\label{namespacekeycpp_a30bc3707493ba61f2165a189e7cbafd4}

\begin{DoxyCompactList}\small\item\em Returns true if all elements of A are nonzero. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_ac60465b61314a3baea857cf9d3579524}{{\footnotesize template$<$class T $>$ }\\bool \hyperlink{namespacekeycpp_ac60465b61314a3baea857cf9d3579524}{keycpp\-::finite} (const T \&a)}\label{namespacekeycpp_ac60465b61314a3baea857cf9d3579524}

\begin{DoxyCompactList}\small\item\em Returns boolean value that is true if a is finite. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_a047f1d1e201235ae75156016fc5b7edf}{{\footnotesize template$<$class T , size\-\_\-t dim$>$ }\\matrix$<$ bool, dim $>$ \hyperlink{namespacekeycpp_a047f1d1e201235ae75156016fc5b7edf}{keycpp\-::finite} (const matrix$<$ T, dim $>$ \&A)}\label{namespacekeycpp_a047f1d1e201235ae75156016fc5b7edf}

\begin{DoxyCompactList}\small\item\em Returns matrix containing boolean values that are true if corresponding elements of A are finite. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_a852be6145adcca15ceaeb5a138651e20}{{\footnotesize template$<$class T $>$ }\\bool \hyperlink{namespacekeycpp_a852be6145adcca15ceaeb5a138651e20}{keycpp\-::isinf} (const T \&a)}\label{namespacekeycpp_a852be6145adcca15ceaeb5a138651e20}

\begin{DoxyCompactList}\small\item\em Returns boolean value that is true if a is infinite. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_a606c5ce0dc3b7ec19ec18f3bbc21d4f2}{{\footnotesize template$<$class T , size\-\_\-t dim$>$ }\\matrix$<$ bool, dim $>$ \hyperlink{namespacekeycpp_a606c5ce0dc3b7ec19ec18f3bbc21d4f2}{keycpp\-::isinf} (const matrix$<$ T, dim $>$ \&A)}\label{namespacekeycpp_a606c5ce0dc3b7ec19ec18f3bbc21d4f2}

\begin{DoxyCompactList}\small\item\em Returns matrix containing boolean values that are true if corresponding elements of A are infinite. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_acc2de8926c54a2048a0d8965e7d70995}{{\footnotesize template$<$class T $>$ }\\matrix$<$ bool $>$ \hyperlink{namespacekeycpp_acc2de8926c54a2048a0d8965e7d70995}{keycpp\-::isempty} (const matrix$<$ T $>$ \&A)}\label{namespacekeycpp_acc2de8926c54a2048a0d8965e7d70995}

\begin{DoxyCompactList}\small\item\em Returns true if matrix is empty. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_a81a8c955cdbeb60181f6bf7d6553ac53}{{\footnotesize template$<$class T $>$ }\\bool \hyperlink{namespacekeycpp_a81a8c955cdbeb60181f6bf7d6553ac53}{keycpp\-::isreal} (const T \&a)}\label{namespacekeycpp_a81a8c955cdbeb60181f6bf7d6553ac53}

\begin{DoxyCompactList}\small\item\em Returns true if a is real. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_af1342fad8b0d8f26c4acc9a65b7ec2dd}{{\footnotesize template$<$class T , size\-\_\-t dim$>$ }\\bool \hyperlink{namespacekeycpp_af1342fad8b0d8f26c4acc9a65b7ec2dd}{keycpp\-::isreal} (const matrix$<$ T, dim $>$ \&A)}\label{namespacekeycpp_af1342fad8b0d8f26c4acc9a65b7ec2dd}

\begin{DoxyCompactList}\small\item\em Returns true if all elements of A are real. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_a005c1190f7087fb1d2545c38c080fd1a}{std\-::complex$<$ double $>$ \hyperlink{namespacekeycpp_a005c1190f7087fb1d2545c38c080fd1a}{keycpp\-::ceil} (const std\-::complex$<$ double $>$ \&a)}\label{namespacekeycpp_a005c1190f7087fb1d2545c38c080fd1a}

\begin{DoxyCompactList}\small\item\em Rounds the real and imaginary parts of std\-::complex$<$double$>$ a towards positive infinity seperately. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_a6f75eb747c57c3e5ff91323f65a02b5f}{{\footnotesize template$<$class T , size\-\_\-t dim$>$ }\\matrix$<$ T, dim $>$ \hyperlink{namespacekeycpp_a6f75eb747c57c3e5ff91323f65a02b5f}{keycpp\-::ceil} (const matrix$<$ T, dim $>$ \&A)}\label{namespacekeycpp_a6f75eb747c57c3e5ff91323f65a02b5f}

\begin{DoxyCompactList}\small\item\em Rounds the elements of A towards positive infinity. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_ab30437496fbd2011521b31aee7961516}{std\-::complex$<$ double $>$ \hyperlink{namespacekeycpp_ab30437496fbd2011521b31aee7961516}{keycpp\-::floor} (const std\-::complex$<$ double $>$ \&a)}\label{namespacekeycpp_ab30437496fbd2011521b31aee7961516}

\begin{DoxyCompactList}\small\item\em Rounds the real and imaginary parts of std\-::complex$<$double$>$ a towards negative infinity seperately. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_a8aad0f0ac8036ee114a14da17aefcb5f}{{\footnotesize template$<$class T , size\-\_\-t dim$>$ }\\matrix$<$ T, dim $>$ \hyperlink{namespacekeycpp_a8aad0f0ac8036ee114a14da17aefcb5f}{keycpp\-::floor} (const matrix$<$ T, dim $>$ \&A)}\label{namespacekeycpp_a8aad0f0ac8036ee114a14da17aefcb5f}

\begin{DoxyCompactList}\small\item\em Rounds the elements of A towards negative infinity. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_ad5d215fa6882ff492cec0c3958fabadb}{{\footnotesize template$<$class T , class U $>$ }\\decltype(std\-::declval$<$ T $>$\\*
()$\ast$std\-::declval$<$ U $>$()) {\bfseries keycpp\-::polyval} (const matrix$<$ T, 2 $>$ \&p, const U \&x)}\label{namespacekeycpp_ad5d215fa6882ff492cec0c3958fabadb}

\item 
\hypertarget{namespacekeycpp_a11ba1fe24c04df74326c1289f82fe980}{{\footnotesize template$<$class T $>$ }\\matrix$<$ T, 2 $>$ \hyperlink{namespacekeycpp_a11ba1fe24c04df74326c1289f82fe980}{keycpp\-::roots} (const matrix$<$ T, 2 $>$ \&p)}\label{namespacekeycpp_a11ba1fe24c04df74326c1289f82fe980}

\begin{DoxyCompactList}\small\item\em Computes all roots of polynomial p by solving for the eigenvalues of the companion matrix. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_a6069a9eec0edfa1d401230013d98765e}{tictoc\-\_\-type \hyperlink{namespacekeycpp_a6069a9eec0edfa1d401230013d98765e}{keycpp\-::tic} ()}\label{namespacekeycpp_a6069a9eec0edfa1d401230013d98765e}

\begin{DoxyCompactList}\small\item\em Start the timer. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_afe03fbbb5126729fb4b9367097acb1d1}{double \hyperlink{namespacekeycpp_afe03fbbb5126729fb4b9367097acb1d1}{keycpp\-::toc} (tictoc\-\_\-type \&Timer)}\label{namespacekeycpp_afe03fbbb5126729fb4b9367097acb1d1}

\begin{DoxyCompactList}\small\item\em Stop the timer. The number of elapsed seconds is returned. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_a9d70a761d33bbc2bdec6b4e0eb43d517}{std\-::string \hyperlink{namespacekeycpp_a9d70a761d33bbc2bdec6b4e0eb43d517}{keycpp\-::sprintf} (const std\-::string \&fmt,...)}\label{namespacekeycpp_a9d70a761d33bbc2bdec6b4e0eb43d517}

\begin{DoxyCompactList}\small\item\em Overload of the C++ function \hyperlink{namespacekeycpp_a9d70a761d33bbc2bdec6b4e0eb43d517}{sprintf()}. This overload provides a more M\-A\-T\-L\-A\-B-\/like interface. Specifically, the output is returned instead of passed by reference. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_aa002278cc556c656aab5b157e81017b6}{matrix$<$ size\-\_\-t, 2 $>$ \hyperlink{namespacekeycpp_aa002278cc556c656aab5b157e81017b6}{keycpp\-::clock} ()}\label{namespacekeycpp_aa002278cc556c656aab5b157e81017b6}

\begin{DoxyCompactList}\small\item\em Returns a vector of integers containing the current\-: year, month, day, hour, minute, and second. This is based on the system clock. The number of hours is based on the 24-\/hour clock. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_ac20bd2ef4fb18cbcdb0f462a89447bd7}{{\footnotesize template$<$class T $>$ }\\matrix$<$ T $>$ \hyperlink{namespacekeycpp_ac20bd2ef4fb18cbcdb0f462a89447bd7}{keycpp\-::pinv} (const matrix$<$ T $>$ \&A)}\label{namespacekeycpp_ac20bd2ef4fb18cbcdb0f462a89447bd7}

\begin{DoxyCompactList}\small\item\em Returns the Moore-\/\-Penrose Pseudoinverse of matrix A. Currently only the S\-V\-D method is implemented. This restricts matrix A to be only square matrices. This is currently slower than inv(), use with care. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_ad70d9156c4b6a75e5b7a4c799f900162}{std\-::string {\bfseries keycpp\-::remove\-White\-Space} (std\-::string in)}\label{namespacekeycpp_ad70d9156c4b6a75e5b7a4c799f900162}

\item 
\hypertarget{namespacekeycpp_ac5c0a8bc58229a412ec2068979b6b84e}{matrix$<$ double $>$ \hyperlink{namespacekeycpp_ac5c0a8bc58229a412ec2068979b6b84e}{keycpp\-::importdata} (std\-::string filename)}\label{namespacekeycpp_ac5c0a8bc58229a412ec2068979b6b84e}

\begin{DoxyCompactList}\small\item\em Returns a matrix containing the data read from a text file. Values must be white space separated. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_a126bda3ea87f21535d3a5da6587985dc}{matrix$<$ std\-::complex$<$ double $>$ $>$ \hyperlink{namespacekeycpp_a126bda3ea87f21535d3a5da6587985dc}{keycpp\-::importdata\-\_\-complex} (std\-::string filename)}\label{namespacekeycpp_a126bda3ea87f21535d3a5da6587985dc}

\begin{DoxyCompactList}\small\item\em Returns a matrix containing the data read from a text file. Values must be white space separated. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_ada4b54cb009afd7217ea23f1778021c1}{{\footnotesize template$<$class T $>$ }\\T \hyperlink{namespacekeycpp_ada4b54cb009afd7217ea23f1778021c1}{keycpp\-::stdev} (matrix$<$ T, 2 $>$ v1)}\label{namespacekeycpp_ada4b54cb009afd7217ea23f1778021c1}

\begin{DoxyCompactList}\small\item\em Returns the standard deviation of inputed vector. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_a3742d74c104a006f442440544dbc22e8}{double \hyperlink{namespacekeycpp_a3742d74c104a006f442440544dbc22e8}{keycpp\-::stdev} (matrix$<$ std\-::complex$<$ double $>$, 2 $>$ v1)}\label{namespacekeycpp_a3742d74c104a006f442440544dbc22e8}

\begin{DoxyCompactList}\small\item\em Returns the standard deviation of inputed vector. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_a8ce2d2a4c296ae28d1081f4345c3a947}{{\footnotesize template$<$class T $>$ }\\T \hyperlink{namespacekeycpp_a8ce2d2a4c296ae28d1081f4345c3a947}{keycpp\-::var} (matrix$<$ T, 2 $>$ v1)}\label{namespacekeycpp_a8ce2d2a4c296ae28d1081f4345c3a947}

\begin{DoxyCompactList}\small\item\em Returns the variance (square of standard deviation) for inputed vector. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_ac94ac14515f1da6cebf6f5d924bd1a35}{double \hyperlink{namespacekeycpp_ac94ac14515f1da6cebf6f5d924bd1a35}{keycpp\-::var} (matrix$<$ std\-::complex$<$ double $>$, 2 $>$ v1)}\label{namespacekeycpp_ac94ac14515f1da6cebf6f5d924bd1a35}

\begin{DoxyCompactList}\small\item\em Returns the variance (square of standard deviation) for inputed vector. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_1_1rng__ns_ad88845cbf85d741821f7d14f97dd1a61}{int \& {\bfseries keycpp\-::rng\-\_\-ns\-::get\-Choice} ()}\label{namespacekeycpp_1_1rng__ns_ad88845cbf85d741821f7d14f97dd1a61}

\item 
\hypertarget{namespacekeycpp_1_1rng__ns_afb757fbaa111ecb5c44c51a913609d19}{std\-::mt19937 \& {\bfseries keycpp\-::rng\-\_\-ns\-::get\-\_\-mt\-\_\-rng} ()}\label{namespacekeycpp_1_1rng__ns_afb757fbaa111ecb5c44c51a913609d19}

\item 
\hypertarget{namespacekeycpp_1_1rng__ns_a6cf6bcfb063a993212a2241fa4b722bc}{std\-::ranlux24\-\_\-base \& {\bfseries keycpp\-::rng\-\_\-ns\-::get\-\_\-lagfib\-\_\-rng} ()}\label{namespacekeycpp_1_1rng__ns_a6cf6bcfb063a993212a2241fa4b722bc}

\item 
\hypertarget{namespacekeycpp_a93e133b94bc27c9b984d0383b01772d4}{void {\bfseries keycpp\-::rng} (size\-\_\-t seed=0, std\-::string generator=\char`\"{}twister\char`\"{})}\label{namespacekeycpp_a93e133b94bc27c9b984d0383b01772d4}

\item 
\hypertarget{namespacekeycpp_af2478c69f713d8664b53d31f25718530}{void {\bfseries keycpp\-::rng} (std\-::string shuffle=\char`\"{}\char`\"{}, std\-::string generator=\char`\"{}\char`\"{})}\label{namespacekeycpp_af2478c69f713d8664b53d31f25718530}

\item 
\hypertarget{namespacekeycpp_a5ef5c1f5951e8182a7c4ec9612f3f7e1}{double \hyperlink{namespacekeycpp_a5ef5c1f5951e8182a7c4ec9612f3f7e1}{keycpp\-::rand} ()}\label{namespacekeycpp_a5ef5c1f5951e8182a7c4ec9612f3f7e1}

\begin{DoxyCompactList}\small\item\em Returns a random double between 0 and 1.\-0. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_ab99a9561cf5654ae722a0879b41d9d73}{matrix$<$ double $>$ \hyperlink{namespacekeycpp_ab99a9561cf5654ae722a0879b41d9d73}{keycpp\-::rand} (const unsigned int \&N)}\label{namespacekeycpp_ab99a9561cf5654ae722a0879b41d9d73}

\begin{DoxyCompactList}\small\item\em Returns an N x N matrix of random doubles between 0 and 1.\-0. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_af6413232f2de6f8ac96efde6531c3055}{matrix$<$ double $>$ \hyperlink{namespacekeycpp_af6413232f2de6f8ac96efde6531c3055}{keycpp\-::rand} (const unsigned int \&M, const unsigned int \&N)}\label{namespacekeycpp_af6413232f2de6f8ac96efde6531c3055}

\begin{DoxyCompactList}\small\item\em Returns an M x N matrix of random doubles between 0 and 1.\-0. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_abbb4c27d8c550f3a522dcd4334986161}{double {\bfseries keycpp\-::randn} ()}\label{namespacekeycpp_abbb4c27d8c550f3a522dcd4334986161}

\item 
\hypertarget{namespacekeycpp_ab55434470472a4b6c511e5a713a4d654}{matrix$<$ double $>$ {\bfseries keycpp\-::randn} (const unsigned int \&N)}\label{namespacekeycpp_ab55434470472a4b6c511e5a713a4d654}

\item 
\hypertarget{namespacekeycpp_a43bbf0f2c5e3c68a4e03abcce5aa63da}{matrix$<$ double $>$ {\bfseries keycpp\-::randn} (const unsigned int \&M, const unsigned int \&N)}\label{namespacekeycpp_a43bbf0f2c5e3c68a4e03abcce5aa63da}

\item 
matrix$<$ std\-::complex$<$ double $>$ $>$ \hyperlink{namespacekeycpp_a11eb4ea6f5e22409e718cfd24de6c17a}{keycpp\-::eig} (const matrix$<$ double $>$ \&A, matrix$<$ std\-::complex$<$ double $>$ $>$ $\ast$vr\-\_\-return, matrix$<$ std\-::complex$<$ double $>$ $>$ $\ast$vl\-\_\-return)
\begin{DoxyCompactList}\small\item\em Double precision eigenvalue solver using L\-A\-P\-A\-C\-K function call. \end{DoxyCompactList}\item 
\hypertarget{namespacekeycpp_a5fa715d09dd31ec18be5cd455c216faa}{matrix$<$ std\-::complex$<$ double $>$ $>$ {\bfseries keycpp\-::lu} (const matrix$<$ std\-::complex$<$ double $>$$>$ \&A\-\_\-in)}\label{namespacekeycpp_a5fa715d09dd31ec18be5cd455c216faa}

\item 
\hypertarget{namespacekeycpp_ac6e9ba154bce04912b775584590b4815}{matrix$<$ double $>$ {\bfseries keycpp\-::lu} (const matrix$<$ double $>$ \&A\-\_\-in)}\label{namespacekeycpp_ac6e9ba154bce04912b775584590b4815}

\item 
\hypertarget{namespacekeycpp_a870bd38d5e2dbf79da93073b9d2d5d9e}{matrix$<$ std\-::complex$<$ double $>$ $>$ {\bfseries keycpp\-::lu} (const matrix$<$ std\-::complex$<$ double $>$$>$ \&A\-\_\-in, int $\ast$iw)}\label{namespacekeycpp_a870bd38d5e2dbf79da93073b9d2d5d9e}

\item 
\hypertarget{namespacekeycpp_ac6ada4f2aa379b6d31cf0a4e1453f809}{matrix$<$ double $>$ {\bfseries keycpp\-::lu} (const matrix$<$ double $>$ \&A\-\_\-in, int $\ast$iw)}\label{namespacekeycpp_ac6ada4f2aa379b6d31cf0a4e1453f809}

\item 
\hypertarget{namespacekeycpp_a29c6eeb7d95bad691033adf85020becc}{{\footnotesize template$<$class T , class U $>$ }\\meshgrid\-\_\-type$<$ T, U $>$ {\bfseries keycpp\-::meshgrid} (const matrix$<$ T $>$ \&x, const matrix$<$ U $>$ \&y)}\label{namespacekeycpp_a29c6eeb7d95bad691033adf85020becc}

\end{DoxyCompactItemize}
